home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / utils / file / objdump.pat / objdump.patch
Encoding:
Text File  |  1994-12-06  |  17.8 KB  |  682 lines
  1.  
  2. Here are some changes I made to objdump which allow it to dump section
  3. contents as raw data.  This is usefull if you need to make an image
  4. of an executable to load into memory with out the help of the 
  5. operating systems.  We use this to make boot images of the Linux
  6. kernel under ELF as well as for dynamic loading of kernel modules.
  7. Another case when they would be useful, is for making ROM Images.
  8.  
  9. I've also enclosed source for another program called encaps which
  10. takes raw data and makes it a .o file.  It's useful for adding 
  11. resources are other data to a program without recompiling.  We use
  12. it to include 16 bit minix assembly in the Linux kernel.
  13.  
  14.     Ross Biro biro@yggdrasil.com
  15.  
  16. ------ CUT HERE ------
  17. ---
  18. *** objdump.c.~1~    Wed Sep 28 13:06:43 1994
  19. --- objdump.c    Mon Nov 14 06:57:47 1994
  20. ***************
  21. *** 15,24 ****
  22. --- 15,28 ----
  23.   
  24.   You should have received a copy of the GNU General Public License
  25.   along with this program; if not, write to the Free Software
  26.   Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  27.   
  28. + /* Added -k, -o, -q options for use with the Linux kernel
  29. +  * 11/94 Ross Biro biro@yggdrasil.com
  30. +  */
  31. + 
  32.   #include "bfd.h"
  33.   #include "sysdep.h"
  34.   #include "getopt.h"
  35.   #include "bucomm.h"
  36.   #include <stdio.h>
  37. ***************
  38. *** 38,47 ****
  39. --- 42,54 ----
  40.   
  41.   extern char *program_version;
  42.   
  43.   int show_version = 0;        /* show the version number */
  44.   int dump_section_contents;    /* -s */
  45. + int dump_section_raw=0;            /* -k */
  46. + int raw_offset=0;               /* -o */
  47. + int quiet=0;            /* -q */
  48.   int dump_section_headers;    /* -h */
  49.   boolean dump_file_header;    /* -f */
  50.   int dump_symtab;        /* -t */
  51.   int dump_dynamic_symtab;    /* -T */
  52.   int dump_reloc_info;        /* -r */
  53. ***************
  54. *** 112,128 ****
  55.   usage (stream, status)
  56.        FILE *stream;
  57.        int status;
  58.   {
  59.     fprintf (stream, "\
  60. ! Usage: %s [-ahifdDrRtTxsl] [-b bfdname] [-m machine] [-j section-name]\n\
  61.          [--archive-headers] [--target=bfdname] [--disassemble]\n\
  62.          [--disassemble-all] [--file-headers] [--section-headers] [--headers]\n\
  63.          [--info] [--section=section-name] [--line-numbers]\n\
  64.          [--architecture=machine] [--reloc] [--full-contents] [--stabs]\n\
  65.          [--syms] [--all-headers] [--dynamic-syms] [--dynamic-reloc]\n\
  66. !        [--version] [--help] objfile...\n\
  67.   at least one option besides -l (--line-numbers) must be given\n",
  68.          program_name);
  69.     exit (status);
  70.   }
  71.   
  72. --- 119,135 ----
  73.   usage (stream, status)
  74.        FILE *stream;
  75.        int status;
  76.   {
  77.     fprintf (stream, "\
  78. ! Usage: %s [-ahifdDkoqrRtTxsl] [-b bfdname] [-m machine] [-j section-name]\n\
  79.          [--archive-headers] [--target=bfdname] [--disassemble]\n\
  80.          [--disassemble-all] [--file-headers] [--section-headers] [--headers]\n\
  81.          [--info] [--section=section-name] [--line-numbers]\n\
  82.          [--architecture=machine] [--reloc] [--full-contents] [--stabs]\n\
  83.          [--syms] [--all-headers] [--dynamic-syms] [--dynamic-reloc]\n\
  84. !        [--version] [--help] [--offset=offset] [--raw] [--quiet] objfile...\n\
  85.   at least one option besides -l (--line-numbers) must be given\n",
  86.          program_name);
  87.     exit (status);
  88.   }
  89.   
  90. ***************
  91. *** 139,148 ****
  92. --- 146,158 ----
  93.     {"full-contents", no_argument, NULL, 's'},
  94.     {"headers", no_argument, NULL, 'h'},
  95.     {"help", no_argument, NULL, 'H'},
  96.     {"info", no_argument, NULL, 'i'},
  97.     {"line-numbers", no_argument, NULL, 'l'},
  98. +   {"offset",  required_argument, NULL, 'o'},
  99. +   {"quiet", no_argument, NULL, 'q'},
  100. +   {"raw", no_argument, NULL, 'k'/* k for kernel */},
  101.     {"reloc", no_argument, NULL, 'r'},
  102.     {"section", required_argument, NULL, 'j'},
  103.     {"section-headers", no_argument, NULL, 'h'},
  104.     {"stabs", no_argument, &dump_stab_section_info, 1},
  105.     {"syms", no_argument, NULL, 't'},
  106. ***************
  107. *** 980,992 ****
  108.         list_matching_formats (matching);
  109.         free (matching);
  110.       }
  111.         return;
  112.       }
  113. ! 
  114. !   printf ("\n%s:     file format %s\n", bfd_get_filename (abfd),
  115. !       abfd->xvec->name);
  116.     if (dump_ar_hdrs)
  117.       print_arelt_descr (stdout, abfd, true);
  118.     if (dump_file_header)
  119.       dump_bfd_header (abfd);
  120.     putchar ('\n');
  121. --- 990,1002 ----
  122.         list_matching_formats (matching);
  123.         free (matching);
  124.       }
  125.         return;
  126.       }
  127. !   if (!quiet)
  128. !     printf ("\n%s:     file format %s\n", bfd_get_filename (abfd),
  129. !         abfd->xvec->name);
  130.     if (dump_ar_hdrs)
  131.       print_arelt_descr (stdout, abfd, true);
  132.     if (dump_file_header)
  133.       dump_bfd_header (abfd);
  134.     putchar ('\n');
  135. ***************
  136. *** 1031,1042 ****
  137.       }
  138.   
  139.     if (bfd_check_format (file, bfd_archive) == true)
  140.       {
  141.         bfd *last_arfile = NULL;
  142. ! 
  143. !       printf ("In archive %s:\n", bfd_get_filename (file));
  144.         for (;;)
  145.       {
  146.         bfd_set_error (bfd_error_no_error);
  147.   
  148.         arfile = bfd_openr_next_archived_file (file, arfile);
  149. --- 1041,1052 ----
  150.       }
  151.   
  152.     if (bfd_check_format (file, bfd_archive) == true)
  153.       {
  154.         bfd *last_arfile = NULL;
  155. !       if (!quiet)
  156. !     printf ("In archive %s:\n", bfd_get_filename (file));
  157.         for (;;)
  158.       {
  159.         bfd_set_error (bfd_error_no_error);
  160.   
  161.         arfile = bfd_openr_next_archived_file (file, arfile);
  162. ***************
  163. *** 1073,1082 ****
  164. --- 1083,1093 ----
  165.   {
  166.     asection *section;
  167.     bfd_byte *data = 0;
  168.     bfd_size_type datasize = 0;
  169.     bfd_size_type i;
  170. +   int err;
  171.   
  172.     for (section = abfd->sections; section != NULL; section =
  173.          section->next)
  174.       {
  175.         int onaline = 16;
  176. ***************
  177. *** 1084,1128 ****
  178.         if (only == (char *) NULL ||
  179.         strcmp (only, section->name) == 0)
  180.       {
  181.         if (section->flags & SEC_HAS_CONTENTS)
  182.           {
  183. !           printf ("Contents of section %s:\n", section->name);
  184.   
  185.             if (bfd_section_size (abfd, section) == 0)
  186.           continue;
  187.             data = (bfd_byte *) xmalloc ((size_t) bfd_section_size (abfd, section));
  188.             datasize = bfd_section_size (abfd, section);
  189.   
  190.   
  191.             bfd_get_section_contents (abfd, section, (PTR) data, 0, bfd_section_size (abfd, section));
  192.   
  193. !           for (i = 0; i < bfd_section_size (abfd, section); i += onaline)
  194. !         {
  195. !           bfd_size_type j;
  196.   
  197. !           printf (" %04lx ", (unsigned long int) (i + section->vma));
  198. !           for (j = i; j < i + onaline; j++)
  199. !             {
  200. !               if (j < bfd_section_size (abfd, section))
  201. !             printf ("%02x", (unsigned) (data[j]));
  202. !               else
  203. !             printf ("  ");
  204. !               if ((j & 3) == 3)
  205. !             printf (" ");
  206. !             }
  207.   
  208. !           printf (" ");
  209. !           for (j = i; j < i + onaline; j++)
  210. !             {
  211. !               if (j >= bfd_section_size (abfd, section))
  212. !             printf (" ");
  213. !               else
  214. !             printf ("%c", isprint (data[j]) ? data[j] : '.');
  215. !             }
  216. !           putchar ('\n');
  217.           }
  218.             free (data);
  219.           }
  220.       }
  221.       }
  222.   }
  223. --- 1095,1155 ----
  224.         if (only == (char *) NULL ||
  225.         strcmp (only, section->name) == 0)
  226.       {
  227.         if (section->flags & SEC_HAS_CONTENTS)
  228.           {
  229. !           if (!quiet)
  230. !         printf ("Contents of section %s:\n", section->name);
  231.   
  232.             if (bfd_section_size (abfd, section) == 0)
  233.           continue;
  234.             data = (bfd_byte *) xmalloc ((size_t) bfd_section_size (abfd, section));
  235.             datasize = bfd_section_size (abfd, section);
  236.   
  237.   
  238.             bfd_get_section_contents (abfd, section, (PTR) data, 0, bfd_section_size (abfd, section));
  239.   
  240. !           if (dump_section_raw) {
  241. !         if (section->vma < raw_offset) continue;
  242.   
  243. !         if (fseek (stdout, section->vma-raw_offset, SEEK_SET)) {
  244. !           perror ("fseek");
  245. !         }
  246.   
  247. !         err =fwrite (data,1, bfd_section_size (abfd, section), stdout);
  248. !         if (err != bfd_section_size (abfd, section)) {
  249. !           perror ("fwrite");
  250. !           return;
  251.           }
  252. +             
  253. +           } else {
  254. +         for (i = 0; i < bfd_section_size (abfd, section); i += onaline)
  255. +           {
  256. +             bfd_size_type j;
  257. + 
  258. +             printf (" %08lx ", (unsigned long int) (i + section->vma));
  259. +             for (j = i; j < i + onaline; j++)
  260. +               {
  261. +             if (j < bfd_section_size (abfd, section))
  262. +               printf ("%02x", (unsigned) (data[j]));
  263. +             else
  264. +               printf ("  ");
  265. +             if ((j & 3) == 3)
  266. +               printf (" ");
  267. +               }
  268. + 
  269. +             printf (" ");
  270. +             for (j = i; j < i + onaline; j++)
  271. +               {
  272. +             if (j >= bfd_section_size (abfd, section))
  273. +               printf (" ");
  274. +             else
  275. +               printf ("%c", isprint (data[j]) ? data[j] : '.');
  276. +               }
  277. +             putchar ('\n');
  278. +           }
  279. +           }
  280.             free (data);
  281.           }
  282.       }
  283.       }
  284.   }
  285. ***************
  286. *** 1504,1514 ****
  287.     program_name = *argv;
  288.     xmalloc_set_program_name (program_name);
  289.   
  290.     bfd_init ();
  291.   
  292. !   while ((c = getopt_long (argc, argv, "ib:m:VdDlfahrRtTxsj:", long_options,
  293.                  (int *) 0))
  294.        != EOF)
  295.       {
  296.         seenflag = true;
  297.         switch (c)
  298. --- 1531,1541 ----
  299.     program_name = *argv;
  300.     xmalloc_set_program_name (program_name);
  301.   
  302.     bfd_init ();
  303.   
  304. !   while ((c = getopt_long (argc, argv, "kqo:ib:m:VdDlfahrRtTxsj:", long_options,
  305.                  (int *) 0))
  306.        != EOF)
  307.       {
  308.         seenflag = true;
  309.         switch (c)
  310. ***************
  311. *** 1549,1558 ****
  312. --- 1576,1595 ----
  313.       case 'd':
  314.         disassemble = true;
  315.         break;
  316.       case 'D':
  317.         disassemble = disassemble_all = true;
  318. +       break;
  319. +     case 'q':
  320. +       quiet = 1;
  321. +       break;
  322. +     case 'k':
  323. +       dump_section_raw = 1;
  324. +       dump_section_contents = 1;
  325. +       break;
  326. +     case 'o':
  327. +       raw_offset = atoi (optarg);
  328.         break;
  329.       case 's':
  330.         dump_section_contents = 1;
  331.         break;
  332.       case 'r':
  333. ------ CUT HERE ------
  334. *** objdump.1.~1~    Thu Sep 15 21:59:29 1994
  335. --- objdump.1    Mon Nov 14 06:50:42 1994
  336. ***************
  337. *** 29,45 ****
  338. --- 29,52 ----
  339.   .RB "[\|" \-i | \-\-info "\|]" 
  340.   .RB "[\|" "\-j\ "\c
  341.   .I section\c
  342.   .RB " | " "\-\-section="\c
  343.   .I section\c
  344. + .RB "[\|" \-k | \-\-raw "\|]" 
  345.   \&\|] 
  346.   .RB "[\|" \-l | \-\-line\-numbers "\|]"
  347.   .RB "[\|" "\-m\ "\c
  348.   .I machine\c
  349.   .RB " | " "\-\-architecture="\c
  350.   .I machine\c
  351.   \&\|] 
  352. + .RB "[\|" "\-o\ "\c
  353. + .I offset\c
  354. + .RB " | " "\-\-offset="\c
  355. + .I offset\c
  356. + \&\|] 
  357. + .RB "[\|" \-q | \-\-quiet "\|]" 
  358.   .RB "[\|" \-r | \-\-reloc "\|]" 
  359.   .RB "[\|" \-R | \-\-dynamic\-reloc "\|]" 
  360.   .RB "[\|" \-s | \-\-full\-contents "\|]"
  361.   .RB "[\|" \-\-stabs "\|]"
  362.   .RB "[\|" \-t | \-\-syms "\|]" 
  363. ***************
  364. *** 181,190 ****
  365. --- 188,206 ----
  366.   Display information only for section \c
  367.   .I name\c
  368.   \&
  369.   
  370.   .TP
  371. + .B \-k
  372. + .TP
  373. + .B \-\-raw
  374. + Dump all the loadable section contents as raw data on stdout.
  375. + Useful for making
  376. + boot images or turning an executable into raw data.  Some architectures
  377. + (such as elf) require that stdout be seekable for this to work.
  378. + 
  379. + .TP
  380.   .B \-l
  381.   .TP
  382.   .B \-\-line\-numbers
  383.   Label the display (using debugging information) with the filename
  384.   and source line numbers corresponding to the object code shown.
  385. ***************
  386. *** 202,211 ****
  387. --- 218,240 ----
  388.   .I machine\c
  389.   \&.  You can list available architectures using the `\|\c
  390.   .B \-i\c
  391.   \|'
  392.   option. 
  393. + 
  394. + .TP
  395. + .BI "\-o " "offset"\c
  396. + .TP
  397. + .BI "\-\-offset=" "offset"\c
  398. + \&
  399. + The offset to make byte 0 of a raw dump.
  400. + 
  401. + .TP
  402. + .B \-q
  403. + .TP
  404. + .B \-\-quiet
  405. + Supress most informational messages, useful with \fB\-k\fP.
  406.   
  407.   .TP
  408.   .B \-r
  409.   .TP
  410.   .B \-\-reloc
  411. ------ CUT HERE ------
  412. /* encaps.c */
  413. /* Copyright (C) 1994 Yggdrasil Computing, Incorporated
  414.    4880 Stevens Creek Blvd. Suite 205
  415.    San Jose, CA 95129-1034
  416.    USA
  417.    Tel (408) 261-6630
  418.    Fax (408) 261-6631
  419.  
  420.    Encaps is free software; you can redistribute it and/or modify
  421.    it under the terms of the GNU General Public License as published by
  422.    the Free Software Foundation; either version 2, or (at your option)
  423.    any later version.
  424.  
  425.    You should have received a copy of the GNU General Public License
  426.    along with this program; see the file COPYING.  If not, write to
  427.    the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  428.  
  429. /* Written by Ross Biro Nov 94 */ 
  430.  
  431. #include <stdlib.h>
  432. #include <stdio.h>
  433. #include <fcntl.h>
  434. #include <malloc.h>
  435. #include <errno.h>
  436. #include <sys/types.h>
  437. #include <sys/stat.h>
  438. #include <sys/mman.h>
  439. #include <unistd.h>
  440. #include <getopt.h>
  441.  
  442. #include "ansidecl.h"
  443. #include <bfd.h>
  444.  
  445. #define obstack_chunk_alloc malloc
  446. #define obstack_chunk_free free
  447.  
  448. #define DEF_SEC_FLAGS SEC_ALLOC|SEC_LOAD|SEC_RELOC|SEC_HAS_CONTENTS
  449.  
  450. /* This is the routine that does most of the work. */
  451. /* file is the name of the output file 
  452.    target is the target type "a.out-i386-linux" for example
  453.    secflags is ored with DEFAULT_SEC_FLAGS and then applied.
  454.             It is used to say if the section is data or code. (Normally 
  455.         SEC_DATA.
  456.    format  is the file format to write (Normally bfd_object)
  457.    symname is the name to give the symbol.
  458.    secname is the name of the section (.data is good)
  459.    fd      is the file descriptor for the data to be put in the file. 
  460. */
  461.  
  462. int
  463. encapsulate (const char *file, const char *target, unsigned long secflags,
  464.          bfd_format format, const char *symname,  char *lengthname,
  465.          const char *secname,
  466.          int fd) {
  467.   bfd *abfd;
  468.   asection *sec;
  469.   size_t length;
  470.   unsigned char *ptr;
  471.   struct stat st;
  472.   asymbol *syms[3];
  473.   asymbol *new;
  474.  
  475.   bfd_init();
  476.   bfd_check_init();
  477.  
  478.   abfd = bfd_openw(file, target);
  479.   
  480.   if (abfd == NULL) {
  481.     fprintf (stderr, "Error Openning %s file %s: %s\n",target, file, 
  482.          bfd_errmsg (bfd_get_error()));
  483.     return (bfd_get_error()<<16| errno);
  484.   }
  485.  
  486. #ifdef __i386__  
  487.   /* This wonderful poorly document call is absolutely necessary. */
  488.   /* The linker deals with this in a much better way.  Perhaps the
  489.      code should be borowed. */
  490.   bfd_default_set_arch_mach (abfd, bfd_arch_i386, 0);
  491. #endif
  492.  
  493.   if (!bfd_set_format (abfd, format)) {
  494.     fprintf (stderr, "Error settting format: %s\n",
  495.          bfd_errmsg (bfd_get_error()));
  496.     return (bfd_get_error()<<16| errno);
  497.   }
  498.  
  499.   sec = bfd_make_section (abfd, secname);
  500.  
  501.   if (sec == NULL) {
  502.     fprintf (stderr, "Error Making Section: %s\n",
  503.          bfd_errmsg (bfd_get_error()));
  504.     return (bfd_get_error()<<16| errno);
  505.   }
  506.  
  507.   if (!bfd_set_section_flags(abfd, sec, DEF_SEC_FLAGS | secflags)) {
  508.     fprintf (stderr, "Error settting section flags %s\n",
  509.          bfd_errmsg (bfd_get_error()));
  510.     return (bfd_get_error()<<16| errno);
  511.   }
  512.   
  513.   /* We are ready for the data. */
  514.   if (fstat (fd, &st)) {
  515.     fprintf (stderr, "Error Stating Data File: %s\n", 
  516.          strerror (errno));
  517.     return (errno);
  518.   }
  519.   
  520.   length = st.st_size;
  521.  
  522.   /* create a new symbol */
  523.  
  524.   new = bfd_make_empty_symbol (abfd);
  525.   if ((unsigned long)new < 4096) {
  526.     fprintf (stderr, "Error allocating symbol: %s\n",
  527.          bfd_errmsg (bfd_get_error()));
  528.     return (bfd_get_error()<<16| errno);
  529.   }
  530.  
  531.   new->name = symname;
  532.   new->section = sec;
  533.   new->flags = BSF_EXPORT;
  534.   new->value =sizeof (char *);
  535.   syms[0]=new;
  536.  
  537.  
  538.   new = bfd_make_empty_symbol (abfd);
  539.   if ((unsigned long)new < 4096) {
  540.     fprintf (stderr, "Error allocating symbol: %s\n",
  541.          bfd_errmsg (bfd_get_error()));
  542.     return (bfd_get_error()<<16| errno);
  543.   }
  544.  
  545.   new->name = lengthname;
  546.   new->section = sec;
  547.   new->flags = BSF_EXPORT;
  548.   new->value =0;
  549.   syms[1]=new;
  550.  
  551.   syms[2]=NULL;
  552.  
  553.   if (!bfd_set_symtab (abfd, syms, 2)) {
  554.     fprintf (stderr, "Error setting symbol table: %s\n",
  555.          bfd_errmsg (bfd_get_error()));
  556.     return (bfd_get_error()<<16| errno);
  557.   }
  558.  
  559.   /* mmap would be good here, but if I do it, I can't easily
  560.      add the length info.  Oh well
  561.   ptr = mmap (0, length, PROT_READ, MAP_FILE|MAP_SHARED,  fd, 0); 
  562.  
  563.   if (ptr == NULL) {
  564.     fprintf (stderr, "Error mmapping Data File: %s\n", 
  565.          strerror (errno));
  566.     return (errno);
  567.   }
  568. */
  569.   ptr = malloc (length + sizeof (char *));
  570.  
  571.   if (ptr == NULL) {
  572.     fprintf (stderr, "Error allocating memory for data file: %s\n", 
  573.          strerror (errno));
  574.     return (errno);
  575.   }
  576.  
  577.   /* this is technically a bug.  For example a ctrl-z bg may break this. */
  578.   if (read (fd, ptr+sizeof (char *), length) != length) {
  579.     fprintf (stderr, "Error reading file: %s\n", 
  580.          strerror (errno));
  581.     return (errno);
  582.   }
  583.   *(unsigned long*)ptr = length;
  584.  
  585.   if (! bfd_set_section_size (abfd, sec, length+sizeof(char *))) {
  586.     fprintf (stderr, "Error settting section size %s:\n",
  587.          bfd_errmsg (bfd_get_error()));
  588.     return (bfd_get_error()<<16| errno);
  589.   }
  590.  
  591.   if (! bfd_set_section_contents (abfd, sec, ptr, 0, length+sizeof (char *))) {
  592.     fprintf (stderr, "Error settting section contents: %s\n",
  593.          bfd_errmsg (bfd_get_error()));
  594.     return (bfd_get_error()<<16| errno);
  595.   }
  596.  
  597.   /* write out everything. */
  598.   bfd_close (abfd);
  599.   return (0);
  600. }
  601.  
  602. void 
  603. usage (char *name) {
  604.   fprintf (stderr, "usage %s: [-f format] [-n secname] [-t target] [-s secflags] output-file input-file symbol-name length-name\n", name);
  605.   fpritnf (stderr,"    --format format        file format to write.\n");
  606.   fpritnf (stderr,"    --section_name         name of the section (normally .data)\n");
  607.   fpritnf (stderr,"    --target target        target name (a.out-linux-i386 elf32-i386)\n");
  608.   fpritnf (stderr,"    --sectionflags flags   flags to put in section header\n");
  609.   exit (1);
  610.        
  611. }
  612.  
  613.  
  614. int main (int argc, char *argv[]) {
  615.   int c;
  616.   char *outfile=NULL;
  617.   char *infile=NULL;
  618.   char *target="a.out-i386-linux";
  619.   int secflags = SEC_DATA;
  620.   bfd_format format = bfd_object;
  621.   char *symname = NULL;
  622.   char *lengthname = NULL;
  623.   char *secname = ".data";
  624.   int fd = -1;
  625.  
  626.   int option_index;
  627.   static struct option long_options[] = {
  628.     {"help", 0, 0, 'h'},
  629.     {"format", 1, 0, 'f'},
  630.     {"section-name", 1, 0, 'n'},
  631.     {"target", 1, 0, 't'},
  632.     {"sectionflags", 1, 0, 's'},
  633.   };
  634.   
  635.   while ((c = getopt_long (argc, argv, "hf:t:n:s:",
  636.                long_options, &option_index)) > 0) {
  637.     switch (c) {
  638.     case 'h':
  639.     case '?':
  640.     default:
  641.       usage(argv[0]);
  642.  
  643.     case 'f':
  644.       format = atoi(optarg);
  645.       break;
  646.  
  647.     case 'n':
  648.       secname = optarg;
  649.       break;
  650.  
  651.     case 't':
  652.       target = optarg;
  653.       break;
  654.  
  655.     case 's':
  656.       secflags=atoi (optarg);
  657.       break;
  658.  
  659.     }
  660.   }
  661.   if (argc - optind != 4) usage(argv[0]);
  662.  
  663.   outfile = argv[optind];
  664.   infile= argv[optind+1];
  665.   symname = argv[optind+2];
  666.   lengthname = argv[optind+3];
  667.   fd = open (infile, O_RDONLY);
  668.   if (fd < 0) {
  669.     fprintf (stderr, "error opening infile %s: %s\n", infile,
  670.          strerror(errno));
  671.     exit (1);
  672.   }
  673.  
  674.   if (encapsulate (outfile, target, secflags, format, symname, lengthname, 
  675.            secname, fd))
  676.     return (1);
  677.  
  678.   return (0);
  679. }
  680.  
  681.  
  682.